Pandas DataFrame létrehozás: Mélyreható betekintés az adatstruktúra inicializálásába

Üdvözöljük a Pythonnal történő adatmanipuláció világában! Szinte minden adatelemzési feladat középpontjában a Pandas könyvtár áll, melynek sarokköve a DataFrame. Gondoljon egy DataFrame-re, mint egy okos, hatékony és rugalmas változatra egy táblázatkezelőnek vagy adatbázis-táblának, amely közvetlenül a Python környezetében él. Ez az elsődleges eszköz az adatok tisztítására, átalakítására, elemzésére és vizualizálására. Mielőtt azonban bármelyik adatvarázslatot végrehajtaná, először el kell sajátítania a DataFrame létrehozásának művészetét. Ennek az alapvető adatstruktúrának az inicializálása alapozhatja meg a teljes elemzését.

Ez az átfogó útmutató a feltörekvő és gyakorló adatelemzők, tudósok és mérnökök globális közönsége számára készült. Felfedezzük a leggyakoribb és leghatékonyabb módszereket a Pandas DataFrame-ek nulláról történő létrehozására. Függetlenül attól, hogy az adatai szótárban, listában, NumPy tömbben vagy más formátumban vannak, ez a cikk biztosítja Önnek az ismereteket és gyakorlati példákat a DataFrame-ek magabiztos és hatékony inicializálásához. Építsük fel az alapokat.

Mi is pontosan a Pandas DataFrame?

Mielőtt elkezdenénk az építkezést, tisztázzuk, mit is építünk. A Pandas DataFrame egy kétdimenziós, méretileg módosítható és potenciálisan heterogén táblázatos adatstruktúra. Bontsuk ezt le:

• Kétdimenziós: Sorokkal és oszlopokkal rendelkezik, akárcsak egy táblázatkezelő.
• Méretileg módosítható: Sorokat és oszlopokat adhat hozzá vagy távolíthat el a DataFrame létrehozása után.
• Heterogén: Az oszlopok különböző adattípusokat tartalmazhatnak. Például az egyik oszlop tartalmazhat számokat (egész vagy lebegőpontos), egy másik szöveget (stringeket), és egy harmadik dátumokat vagy logikai értékeket (Igaz/Hamis).

Egy DataFrame három fő komponenst tartalmaz:

1. Az Adatok: A struktúrában tárolt tényleges értékek, sorokba és oszlopokba rendezve.
2. Az Index: A sorok címkéi. Ha nem ad meg indexet, a Pandas alapértelmezett, 0-tól induló indexet hoz létre. Az index hatékony módot biztosít az adatok elérésére és illesztésére.
3. Az Oszlopok: Az oszlopok címkéi. Ezek kulcsfontosságúak a DataFrame-en belüli specifikus adatsorok eléréséhez.

Ennek a struktúrának a megértése kulcsfontosságú ahhoz, hogy hatékonyan hozzon létre és manipuláljon DataFramer-ket.

Az Alap: A Pandas importálása

Először is. Ahhoz, hogy a Pandast használja, importálnia kell a könyvtárat a Python szkriptjébe vagy jegyzetfüzetébe. A világszerte elfogadott konvenció, amelyet a szakemberek követnek, az, hogy az pd alias-szal importálják. Ez az egyszerű alias olvashatóbbá és tömörebbé teszi a kódot.

import pandas as pd
import numpy as np # Often used alongside Pandas, so we'll import it too.

Ezzel az egyetlen sorral feloldotta a Pandas könyvtár teljes erejét. Most pedig térjünk rá ennek az útmutatónak a lényegére: a DataFrame-ek létrehozására.

Alapvető létrehozási módszerek: Egyszerűtől a komplexig

A pd.DataFrame() konstruktor hihetetlenül sokoldalú. Sok különböző típusú bemenetet képes elfogadni. Most megvizsgáljuk a leglényegesebb módszereket, a leggyakoribbtól a speciálisabb esetek felé haladva.

1. DataFrame létrehozása listák vagy tömbök szótárából

Ez vitathatatlanul a leggyakoribb és legintuitívabb módszer egy DataFrame létrehozására. Egy Python szótárral kezdődik, ahol a kulcsok az oszlopnevek, az értékek pedig listák (vagy NumPy tömbök vagy Pandas Series objektumok), amelyek az egyes oszlopok adatait tartalmazzák.

Hogyan működik: A Pandas minden szótárkulcsot egy oszlopfejléhez, és minden értéklistát az adott oszlop soraihoz rendel. Fontos követelmény, hogy minden lista azonos hosszúságú legyen, mivel minden lista egy teljes oszlopnyi adatot képvisel.

Példa:

Hozzon létre egy DataFrame-et, amely különböző világvárosokról tartalmaz információkat.

# Data organized by column city_data = { 'City': ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'], 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } # Create the DataFrame df_from_dict = pd.DataFrame(city_data) print(df_from_dict)

Kimenet:

         City Country  Population_Millions  Is_Coastal
0       Tokyo   Japan                 37.3        True
1       Delhi   India                 32.0       False
2    Shanghai   China                 28.5        True
3   São Paulo  Brazil                 22.4       False
4      Mumbai   India                 20.9        True

Főbb tanulság: Ez a módszer tökéletes, ha az adatai természetesen rendezettek funkció vagy kategória szerint. Tiszta, olvasható, és közvetlenül táblázatos formátumba fordítja a szótára struktúráját.

2. DataFrame létrehozása szótárak listájából

Egy alternatív és ugyanolyan hatékony módszer az, ha egy listát használunk, ahol minden elem egy szótár. Ebben a struktúrában minden szótár egyetlen sort képvisel, és annak kulcsai képviselik az adott sor adatainak oszlopneveit.

Hogyan működik: A Pandas végighalad a listán. Minden szótárhoz létrehoz egy új sort. A szótárkulcsok az oszlopok meghatározására szolgálnak. Ez a módszer hihetetlenül rugalmas, mert ha egy szótárban hiányzik egy kulcs, a Pandas automatikusan kitölti az adott cellát a megfelelő sorban NaN (Not a Number) értékkel, ami a hiányzó adatok standard jelölője a Pandasban.

Példa:

Mutassuk be ugyanazt a városadatot, de ezúttal rekordok listájaként strukturálva.

# Data organized by row (record) records_data = [ {'City': 'Tokyo', 'Country': 'Japan', 'Population_Millions': 37.3, 'Is_Coastal': True}, {'City': 'Delhi', 'Country': 'India', 'Population_Millions': 32.0, 'Is_Coastal': False}, {'City': 'Shanghai', 'Country': 'China', 'Population_Millions': 28.5}, {'City': 'São Paulo', 'Country': 'Brazil', 'Population_Millions': 22.4, 'Is_Coastal': False}, {'City': 'Cairo', 'Country': 'Egypt', 'Timezone': 'EET'} # Note the different structure ] # Create the DataFrame df_from_list_of_dicts = pd.DataFrame(records_data) print(df_from_list_of_dicts)

Kimenet:

         City Country  Population_Millions  Is_Coastal Timezone
0       Tokyo   Japan                 37.3        True      NaN
1       Delhi   India                 32.0       False      NaN
2    Shanghai   China                 28.5         NaN      NaN
3   São Paulo  Brazil                 22.4       False      NaN
4       Cairo   Egypt                  NaN         NaN      EET

Figyelje meg, hogy a Pandas milyen elegánsan kezelte az inkonzisztenciákat. Shanghai 'Is_Coastal' értéke NaN, mert hiányzott a szótárából. Egy új 'Timezone' oszlop jött létre Kairó számára, NaN értékkel az összes többi város esetében. Ez kiváló választássá teszi félig strukturált adatokkal való munkához, például API-kból származó JSON válaszokkal.

Főbb tanulság: Használja ezt a módszert, ha az adatai rekordok vagy megfigyelések sorozataként érkeznek. Robusztus a hiányzó adatok és a rekordstruktúra eltéréseinek kezelésében.

3. DataFrame létrehozása NumPy tömbből

Azok számára, akik tudományos számítástechnikával, gépi tanulással vagy bármilyen nagy számítási műveletekkel járó területtel foglalkoznak, az adatok gyakran NumPy tömbökből származnak. A Pandas a NumPy-ra épül, így a kettő közötti integráció zökkenőmentes és rendkívül hatékony.

Hogyan működik: Egy kétdimenziós NumPy tömböt ad át a pd.DataFrame() konstruktornak. Alapértelmezés szerint a Pandas egész szám alapú indexeket és oszlopokat hoz létre. Azonban (és javasolt is) értelmes címkéket adhat meg az index és columns paraméterek segítségével.

Példa:

Hozzon létre egy DataFrame-et egy véletlenszerűen generált 5x4-es NumPy tömbből, amely időbeli érzékelőméréseket képvisel.

# Create a 5x4 NumPy array with random data data_np = np.random.rand(5, 4) # Define column and index labels columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D'] index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04']) # Create the DataFrame df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns) print(df_from_numpy)

Kimenet (az Ön véletlenszerű számai eltérhetnek):

                           Sensor_A  Sensor_B  Sensor_C  Sensor_D
2023-10-27 10:00:00  0.123456  0.987654  0.555555  0.111111
2023-10-27 10:01:00  0.234567  0.876543  0.666666  0.222222
2023-10-27 10:02:00  0.345678  0.765432  0.777777  0.333333
2023-10-27 10:03:00  0.456789  0.654321  0.888888  0.444444
2023-10-27 10:04:00  0.567890  0.543210  0.999999  0.555555

Ebben a példában egy hatékony funkciót is bemutattunk: a DatetimeIndex használatát idősoros adatokhoz, ami a Pandasban az idő alapú elemzési képességek széles skáláját tárja fel.

Főbb tanulság: Ez a legmemória-hatékonyabb módszer egy DataFrame létrehozására homogén numerikus adatokból. Ez a standard választás, amikor olyan könyvtárakkal dolgozunk, mint a NumPy, Scikit-learn vagy TensorFlow.

4. DataFrame létrehozása listák listájából

Ez a módszer koncepcionálisan hasonló a NumPy tömbből történő létrehozáshoz, de standard Python listákat használ. Ez egy egyszerű módja a beágyazott lista formátumban tárolt táblázatos adatok konvertálásának.

Hogyan működik: Adjon meg egy listát, ahol minden belső lista egy adatsort képvisel. Mint a NumPy tömbök esetében, erősen ajánlott az oszlopnevek megadása a columns paraméteren keresztül az áttekinthetőség érdekében.

Példa:

# Data as a list of rows product_data = [ ['P001', 'Laptop', 1200.00, 'Electronics'], ['P002', 'Mouse', 25.50, 'Electronics'], ['P003', 'Desk Chair', 150.75, 'Furniture'], ['P004', 'Keyboard', 75.00, 'Electronics'] ] # Define column names column_names = ['ProductID', 'ProductName', 'Price_USD', 'Category'] # Create the DataFrame df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names) print(df_from_list_of_lists)

Kimenet:

  ProductID ProductName  Price_USD     Category
0      P001      Laptop    1200.00  Electronics
1      P002       Mouse      25.50  Electronics
2      P003  Desk Chair     150.75    Furniture
3      P004    Keyboard      75.00  Electronics

Főbb tanulság: Ez egy egyszerű és hatékony módszer, ha az adatai már sorok listájaként vannak strukturálva, például amikor egy olyan fájlformátumból olvas be, amelynek nincsenek fejlécei.

Haladó inicializálás: DataFrame testreszabása

A nyers adatok biztosításán túl a pd.DataFrame() konstruktor számos paramétert kínál az új DataFrame struktúrájának és tulajdonságainak szabályozására a létrehozás pillanatától kezdve.

Az index megadása

Már láttuk az `index` paramétert működés közben. Az index a DataFrame kulcsfontosságú része, amely címkéket biztosít a sorokhoz, és gyors keresésekhez, adatok illesztéséhez és sok máshoz használható. Bár a Pandas alapértelmezett numerikus indexet (0, 1, 2, ...) biztosít, egy értelmes index beállítása sokkal könnyebbé teheti az adatokkal való munkát.

Példa: Használjuk újra a listák szótárából készült példánkat, de a `City` oszlopot állítsuk be indexként a létrehozáskor.

city_data = { 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } city_names = ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'] # Create the DataFrame with a custom index df_with_index = pd.DataFrame(city_data, index=city_names) print(df_with_index)

Kimenet:

          Country  Population_Millions  Is_Coastal
Tokyo       Japan                 37.3        True
Delhi       India                 32.0       False
Shanghai    China                 28.5        True
São Paulo  Brazil                 22.4       False
Mumbai      India                 20.9        True

Mostantól ezekkel az értelmes címkékkel érheti el a sori adatokat, például a df_with_index.loc['Tokyo'] paranccsal.

Adattípusok szabályozása (`dtype`)

A Pandas elég jól megállapítja az adattípusokat (pl. felismeri a számokat, szövegeket és logikai értékeket). Azonban néha egy oszlophoz meghatározott adattípust kell kényszeríteni a memóriahatékonyság biztosítása vagy speciális műveletek engedélyezése érdekében. A `dtype` paraméter biztosítja ezt a vezérlést.

Példa: Képzelje el, hogy vannak termékazonosítóink, amelyek számoknak tűnnek, de szövegként (stringként) kell kezelni őket.

data = { 'ProductID': [101, 102, 103], 'Stock': [50, 75, 0] } # Create DataFrame while specifying a dtype for 'ProductID' df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'}) print(df_types.dtypes)

Kimenet:

ProductID    object
Stock         int32
dtype: object

Figyelje meg, hogy a Pandasban a `str` `object` ként jelenik meg. Az `dtype` explicit beállításával megakadályozzuk, hogy a Pandas a `ProductID`-t számként kezelje, ami hibás számításokhoz vagy rendezési problémákhoz vezethet. Specifikusabb egész szám típusok, mint az `int32` használata az alapértelmezett `int64` helyett, jelentős memóriát takaríthat meg nagy adathalmazok esetén.

Gyakorlati forgatókönyvek és bevált módszerek

A megfelelő létrehozási módszer kiválasztása az adatok eredeti formátumától függ. Íme egy egyszerű döntési útmutató:

• Oszlopokban vannak az adatai (pl. egy lista funkciónként)? Használjon listák szótárát. Ez természetes illeszkedés.
• Az adatai rekordok sorozatát képezik (pl. egy JSON API-ból)? Használjon szótárak listáját. Kiválóan kezeli a hiányzó vagy extra mezőket a rekordokban.
• Az adatai numerikusak és rácsban vannak (pl. tudományos számításból)? Használjon NumPy tömböt. Ez a legperformánsabb opció ehhez a felhasználási esethez.
• Az adatai egyszerű, soronkénti táblázatos formátumban vannak fejlécek nélkül? Használjon listák listáját és adja meg az oszlopneveket külön.

Kerülendő gyakori hibák

1. Nem egyenlő hosszúságú listák a szótárban: Ez gyakori hiba. Amikor listák szótárából hoz létre DataFrame-et, minden listának pontosan ugyanannyi elemet kell tartalmaznia. Ha nem, a Pandas `ValueError`-t fog dobni. Mindig győződjön meg arról, hogy az oszlopadatai azonos hosszúságúak a létrehozás előtt.
2. Az index figyelmen kívül hagyása: Az alapértelmezett, 0-tól induló indexre támaszkodás sok esetben rendben van, de ha az adatai természetes azonosítóval rendelkeznek (például termékazonosító, felhasználói azonosító vagy specifikus időbélyeg), akkor annak indexként való beállítása a kezdetektől egyszerűsítheti a kódját később.
3. Adattípusok elfelejtése: Bár a Pandas az esetek többségében jól kikövetkezteti a típusokat, nagy adathalmazok vagy vegyes típusú oszlopok esetén a teljesítmény romolhat. Legyen proaktív az `dtype` beállításában azoknál az oszlopoknál, amelyeket kategóriákként, stringként vagy specifikus numerikus típusokként kell kezelni, hogy memóriát takarítson meg és elkerülje a hibákat.

Inicializáción túl: DataFrame-ek létrehozása fájlokból

Bár ez az útmutató a memóriában lévő Python objektumokból történő DataFrame-ek létrehozására összpontosít, kulcsfontosságú tudni, hogy a valós forgatókönyvek többségében az adatai külső fájlból származnak majd. A Pandas rendkívül optimalizált olvasófüggvények készletét biztosítja erre a célra, többek között:

• pd.read_csv(): A vesszővel elválasztott értékek fájljaihoz, az adatimportálás igáslova.
• pd.read_excel(): Adatok olvasására Microsoft Excel táblázatokból.
• pd.read_json(): Adatok olvasására JSON fájlokból vagy stringekből.
• pd.read_sql(): Adatbázis-lekérdezés eredményeinek közvetlen beolvasására DataFrame-be.
• pd.read_parquet(): Olvasáshoz a hatékony, oszloporientált Parquet fájlformátumból.

Ezek a függvények a következő logikus lépés a Pandas-utazásában. Az elsajátításuk lehetővé teszi, hogy gyakorlatilag bármilyen forrásból adatokat importáljon egy hatékony DataFrame struktúrába.

Összefoglalás: Az adatok elsajátításának alapja

A Pandas DataFrame a központi adatstruktúra minden komoly Python adatfeldolgozáshoz. Mint láthattuk, a Pandas rugalmas és intuitív eszközöket kínál ezen struktúrák inicializálásához számos különböző formátumból. Azzal, hogy megérti, hogyan hozhat létre DataFrame-et szótárakból, listákból és NumPy tömbökből, szilárd alapot épített adatelemzési projektjeihez.

A kulcs az, hogy kiválassza azt a módszert, amely a legjobban illeszkedik az adatok eredeti struktúrájához. Ez nemcsak tisztábbá és olvashatóbbá, hanem hatékonyabbá is teszi a kódját. Innen készen áll arra, hogy továbblépjen az adat tisztítás, feltárás, átalakítás és vizualizáció izgalmas feladataira. Jó kódolást!